# -*- coding: latin-1 -*-
import WebServices.soap
import wx
import sys
import wx.animate
import types
import Excepciones
import datosfijos
import clasesmultiproposito.archivo_configuracion
#Aplicaciones
PRG_NINGUNO = 0
PRG_AFILIACIONES = 1
PRG_LIBRAMIENTOS = 2
PRG_LIQUIDACIONES = 4
PRG_FIZCALIZACIONES = 8
PRG_SUMINISTROS = 16
PRG_STOCK = 128
PRG_TODOS = 65535

class BasePermisos():
    def __init__(self):
        self.__Permisos = {}
        self.__grupos = {}
    def AgregarGrupo(self,Clave,IdGrupo,IdUsuario,
                        NombreGrupo,DescGrupo,IdAplicacion):
        valor = {'IdGrupo':IdGrupo,'IdUsuario':IdUsuario,
                'NombreGrupo':NombreGrupo,'DescGrupo':DescGrupo,
                'IdAplicacion':IdAplicacion}
        self.Grupos[Clave]= valor 
    def _AddGrupo(self
                  ,idgrp,IdGrupo,nombregrupo
                  ,IdUsuario
                  ,DescGrupo,IdAplicacion):
        if self.__grupos.has_key(idgrp)== True:
            aux = self.__grupos[idgrp]
            aux[nombregrupo]= {'IdGrupo':IdGrupo,'IdUsuario':IdUsuario,
                'NombreGrupo':nombregrupo,'DescGrupo':DescGrupo,
                'IdAplicacion':IdAplicacion}
            self.__grupos[idgrp]= aux
        else:
            self.__grupos[idgrp]= {nombregrupo:{'IdGrupo':IdGrupo,'IdUsuario':IdUsuario,
                                     'NombreGrupo':nombregrupo,'DescGrupo':DescGrupo,
                                     'IdAplicacion':IdAplicacion}}
    def _GetGrupos(self,idgrp):
        return self.__grupos[idgrp]
    def _PerteneceAlGrupo(self,idgrp,tag):
        aux = self.__grupos[idgrp]
        if aux.has_key(tag)== True:
            return True
        else:
            return False
        
    def _AddPermiso(self,idgrp,tag,descripcion):
        if self.__Permisos.has_key(idgrp)== True:
            aux = self.__Permisos[idgrp]
            aux[tag] = descripcion
            self.__Permisos[idgrp]= aux
        else:
            self.__Permisos[idgrp]= {tag : descripcion}
    def _GetPermisos(self):
        return self.__Permisos
    def _GetTienePermiso(self,idgrp,tag):
        if self.__Permisos.has_key(idgrp)== True:
            aux = self.__Permisos[idgrp]
            if aux.has_key(tag)== True:
                return True
            else:
                return False
        else:
            raise KeyError , "No tiene permisos para el perfil seleccionado"
    def _TienePermisosParaEstePerfil(self,idgrp):
        if self.__Permisos.has_key(idgrp)== True:
            aux = self.__Permisos[idgrp]
            if len(aux)> 0:
                return True
            else:
                return False
        else:
            return False
class BaseDatosFijos():
    def __init__(self):
        self.__DatosFijos = {}
    def _CrearDiccDatosFijos(self):
        self.__DatosFijos = {}
    def _AgregarDatoFijo(self,NombreDatoFijo, valor):
        self.__DatosFijos[NombreDatoFijo] = valor
    def _getTodosDatosFijos(self):
        return self.__DatosFijos
    def getDatoFijo(self,Key):
        if self.__DatosFijos.has_key(Key)== True:
            return self.__DatosFijos[Key]
        else:
            raise KeyError , "No se encontro el dato fijo"

class BaseUsuario():
    def __init__(self):
        self.__IdUsuario = -1
        self.__NombreUsuario = ""
        self.__LoginUsuario = ""
        self.__ClaveUsuario = ""
        self.__IdDependencia = ""
        self.__DescDependencia = ""
        self.__CodConsejo = ""
        self.__Habilitado = False
        self.__TipoDependencia = ""
    def getIdUsuario(self):
        return self.__IdUsuario
    def getNombreUsuario(self):
        return self.__NombreUsuario
    def getLoginUsuario(self):
        return self.__LoginUsuario
    def getClaveUsuario(self):
        return self.__ClaveUsuario
    def getIdDependencia(self):
        return self.__IdDependencia
    def getDescDependencia(self):
        return self.__DescDependencia
    def getCodConsejo(self):
        return self.__CodConsejo
    def getHabilitado(self):
        return self.__Habilitado
    def getTipoDependencia(self):
        return self.__TipoDependencia
    def _setIdUsuario(self, value):
        self.__IdUsuario = value
    def _setNombreUsuario(self, value):
        self.__NombreUsuario = value
    def _setLoginUsuario(self, value):
        self.__LoginUsuario = value
    def _setClaveUsuario(self, value):
        self.__ClaveUsuario = value
    def _setIdDependencia(self, value):
        self.__IdDependencia = value
    def _setDescDependencia(self, value):
        self.__DescDependencia = value
    def _setCodConsejo(self, value):
        self.__CodConsejo = value
    def _setHabilitado(self, value):
        self.__Habilitado = value
    def _setTipoDependencia(self, value):
        self.__TipoDependencia = value


class Manejador(BaseUsuario
                   ,BasePermisos
                   ,BaseDatosFijos
                   ):
    def __init__(self):
        self.__handler = None
        BaseUsuario.__init__(self)
        BasePermisos.__init__(self)
        BaseDatosFijos.__init__(self)
        self.__ArchivoConfiguracion = clasesmultiproposito.archivo_configuracion.ArchivosDeConfiguracion()
        self.__UrlServidorWeb = ""
        self.__HostServidorWeb = ""
        self.__NameSpace = ""
        self.__Reintentos = 1
        self.__TipoServidor = WebServices.soap.SERVIDOR_ASP
        self.__ConProxy = False
        self.__IpProxy = ""
        self.__PuertoProxy = 8080
        self.__UsuarioProxy = ""
        self.__PassProxy = ""
        self.__Proxy = ""
        self.__CorreoEntrante = ""
        self.__CorreoSaliente = ""
        self.__PuertoCorreoEntrante = 110
        self.__PuertoCorreoSaliente = 25
        self.__CuentaCorreo = ""
        self.__PassCorreo = ""
        self.__PerfilActual = -1
        self.__TieneStockHijos = False
        self.__TieneStockPadre = False
    def getHandler(self):
        return self.__handler
    def getPerfilActual(self):
        return self.__PerfilActual
    def getUrlServidorWeb(self):
        return self.__UrlServidorWeb
    def getHostServidorWeb(self):
        return self.__HostServidorWeb
    def getNameSpace(self):
        return self.__NameSpace
    def getReintentos(self):
        return self.__Reintentos
    def getTipoServidor(self):
        return self.__TipoServidor
    def getConProxy(self):
        return self.__ConProxy
    def getIpProxy(self):
        return self.__IpProxy
    def getPuertoProxy(self):
        return self.__PuertoProxy
    def getUsuarioProxy(self):
        return self.__UsuarioProxy
    def getPassProxy(self):
        return self.__PassProxy
    def getProxy(self):
        return self.__Proxy
    def getCorreoEntrante(self):
        return self.__CorreoEntrante
    def getCorreoSaliente(self):
        return self.__CorreoSaliente
    def getPuertoCorreoEntrante(self):
        return self.__PuertoCorreoEntrante
    def getPuertoCorreoSaliente(self):
        return self.__PuertoCorreoSaliente
    def getCuentaCorreo(self):
        return self.__CuentaCorreo
    def getPassCorreo(self):
        return self.__PassCorreo
    def getTieneStockHijos(self):
        return self.__TieneStockHijos
    def getTieneStockPadre(self):
        return self.__TieneStockPadre
    def getTienePermisoPara(self,tag):
        return self._GetTienePermiso(self.getPerfilActual(), tag)
    def getTienePermisosParaEstePerfil(self,idgrp):
        return self._TienePermisosParaEstePerfil(idgrp)
    def getIDGrupoStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getId()
        
    def getNombreStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getNombre()
    def getDescripcionStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getDescripcion()
    def getUbicacionStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getUbicacion()
    def getDireccionStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getDireccion()
            
    def getLocalidadStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getLocalidad()
    def getProvinciaStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getProvincia()
    def getCodigoPostalStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getCodPostal()
            
    def getTelefonosStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getTelefonos()
    def getEmailStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getEmail()
    def getGenerarNroSerie(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                if mGrupo.getGenerarNroSerie()== "True":
                    return True
                else:
                    return False
        
    def getTipoStock(self):
        mGrupo = datosfijos.GruposStock()
        mPerfiles = self.getDatoFijo("Perfiles")
        for key in mPerfiles:
            mGrupo = mPerfiles[key]
            if mGrupo.getId()== str(self.getPerfilActual()):
                return mGrupo.getTipoStock()
    def getStockPadre(self):
        if self.getTipoStock()== "Cabecera":
            return self.getPerfilActual()
        else:
            mPadre = datosfijos.DependenciasxStock()
            dict = self.getDatoFijo("PadreGrupoStock")
            for key in dict:
                mPadre = dict[key]
                if mPadre.getId() == str(self.getPerfilActual()):
                    return mPadre.getIdPadre()
    def getTieneStockHijos(self):
        mGrupo = datosfijos.StockHijos()
        dict = self.getDatoFijo("GrupoStockHijos")
        for key in dict:
            mGrupo = dict[key]
            if mGrupo.getIdPadre()== str(self.getPerfilActual()):
                return True
        return False
    def setHandler(self,mHandler = None):
        self.__handler = mHandler
    def SetPerfilActual(self,NewPerfil):
        if type(NewPerfil)== types.IntType:
            self.__PerfilActual = NewPerfil
            return True
        else:
            raise TypeError , "Se esperaba dato de tipo entero para perfil actual"
    def _setUrlServidorWeb(self, value):
        self.__UrlServidorWeb = value
    def _setHostServidorWeb(self, value):
        self.__HostServidorWeb = value
    def _setNameSpace(self,value):
        self.__NameSpace = value
    def _setReintentos(self, value):
        self.__Reintentos = value
    def _setTipoServidor(self, value):
        self.__TipoServidor = value
    def _setConProxy(self, value):
        self.__ConProxy = value
    def _setIpProxy(self, value):
        self.__IpProxy = value
    def _setPuertoProxy(self, value):
        self.__PuertoProxy = value
    def _setUsuarioProxy(self, value):
        self.__UsuarioProxy = value
    def _setPassProxy(self, value):
        self.__PassProxy = value
    def _setProxy(self, value):
        self.__Proxy = value
    def _setCorreoEntrante(self, value):
        self.__CorreoEntrante = value
    def _setCorreoSaliente(self, value):
        self.__CorreoSaliente = value
    def _setPuertoCorreoEntrante(self, value):
        self.__PuertoCorreoEntrante = value
    def _setPuertoCorreoSaliente(self, value):
        self.__PuertoCorreoSaliente = value
    def _setCuentaCorreo(self, value):
        self.__CuentaCorreo = value
    def _setPassCorreo(self, value):
        self.__PassCorreo = value
    def _setTieneStockHijos(self, value):
        self.__TieneStockHijos = value
    def _setTieneStockPadre(self, value):
        self.__TieneStockPadre = value
    def __CargarDatosDeConexion(self):
        Archivo = clasesmultiproposito.archivo_configuracion.ArchivosDeConfiguracion()
        if Archivo.AbrirArchivo('Config.cfg')== True:
            if Archivo.GetSeccion("Proxy", "conproxy")== "True":
                self._setConProxy(True)
                self._setIpProxy(Archivo.GetSeccion("Proxy", "direccion"))
                self._setPuertoProxy(Archivo.GetSeccion("Proxy", "puerto"))
                self._setUsuarioProxy(Archivo.GetSeccion("Proxy", "user"))
                self._setPassProxy(Archivo.GetSeccion("Proxy", "pass"))
                self._setProxy("http://" + self.getUsuarioProxy() + ":" + self.getPassProxy() + "@" + self.getIpProxy() + ":" + self.getPuertoProxy())
            else:
                self._setConProxy(False)
                self._setIpProxy("")
                self._setPuertoProxy(8080)
                self._setUsuarioProxy("")
                self._setPassProxy("")
                self._setProxy(None)
            
            self._setUrlServidorWeb(Archivo.GetSeccion("ServidorWeb", "urlws"))
            self._setHostServidorWeb(Archivo.GetSeccion("ServidorWeb", "host"))
            self._setNameSpace(Archivo.GetSeccion("ServidorWeb", "namespace"))
            self._setReintentos(int(Archivo.GetSeccion("ServidorWeb", "reintentos")))
            if Archivo.GetSeccion("ServidorWeb", "servidornet")== "True":
                self._setTipoServidor(WebServices.soap.SERVIDOR_ASP)
            elif Archivo.GetSeccion("ServidorWeb", "servidorweb2py")== "True":
                self._setTipoServidor(WebServices.soap.SERVIDOR_WEB2PY)
            else:
                raise Error_Logeo(
                        "NewSeguridad"
                        , "__CargarDatosDeConexion"
                        , "Error al establecer el tipo de servidor web a utilizar")
            self._setCorreoEntrante(Archivo.GetSeccion("ServidorCorreo", "correoentrante(pop3)"))
            self._setPuertoCorreoEntrante(Archivo.GetSeccion("ServidorCorreo", "puertocorreoentrante"))
            self._setCorreoSaliente(Archivo.GetSeccion("ServidorCorreo", "correosaliente(smtp)"))
            self._setPuertoCorreoSaliente(Archivo.GetSeccion("ServidorCorreo", "puertocorreosaliente"))
            self._setCuentaCorreo(Archivo.GetSeccion("ServidorCorreo", "cuenta"))
            self._setPassCorreo(Archivo.GetSeccion("ServidorCorreo", "pass"))
            return True
        else:
            raise Error_Logeo(
                    "NewSeguridad"
                    , "__CargarDatosDeConexion"
                    , "Aun no configuro el programa, ingrese por el menu opciones")
    def Logear(self,UserName,Password):
        self.__handler.SetearProgreso(20,"Espere por favor...")
        if self.__CargarDatosDeConexion()== True:
            if self.__Logear(UserName, Password)== True:
                if self.__TraerPermisos()== True:
                    if self.__CargarDatosFijos()== True:
                        return True
    def __Logear(self,UserName,Password):
        WebService = WebServices.soap.WebService(
                        self.getUrlServidorWeb()
                        , self.getHostServidorWeb()
                        , self.getProxy()
                        , self.getTipoServidor()
                        ,self.getReintentos())
        parametros = {
                      1:('Login',UserName)
                    ,2:('Clave',Password)
                    ,3:('TipoRespuesta','Python')
                    }
        if WebService.Enviar('AcreditarUsuario'
                        ,'www.osplad.org.ar'
                        , parametros) == True:
            if WebService.Count()>0:
                while WebService.BOF()!= True and WebService.EOF()!= True:
                    self._setIdUsuario(WebService.Fields("IdUsr"))
                    self._setNombreUsuario(WebService.Fields("Nombre")+ " " + WebService.Fields("Apellido"))
                    self._setCodConsejo(WebService.Fields("CodConsejo"))
                    self._setIdDependencia(WebService.Fields("IdDependencia"))
                    if WebService.Fields("Habilitado")== "True":
                        self._setHabilitado(True)
                    else:
                        self._setHabilitado(False)
                    self._setDescDependencia(WebService.Fields("DescDependencia"))
                    self._setTipoDependencia(WebService.Fields("TipoDependencia"))
                    WebService.MoveNext()
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "LogearUsuario"
                                , "Usuario o pass incorrecta")
                
    def __TraerGrupos(self):
        WebService = WebServices.soap.WebService(
                        self.getUrlServidorWeb()
                        , self.getHostServidorWeb()
                        , self.getProxy()
                        , self.getTipoServidor()
                        , self.getReintentos())
        parametros = {
            1:('Id',str(self.getIdUsuario()))
            ,2:('TipoRespuesta','Python')}
        
        if WebService.Enviar('SEG_QueGruposTiene'
                             ,'www.osplad.org.ar'
                             , Parametros) == True:
            if WebService.Count()> 0:
                while WebService.BOF()!= True and WebService.EOF()!= True:
                    self._AddGrupo(idgrp, IdGrupo, nombregrupo, IdUsuario, DescGrupo, IdAplicacion)
                    WebService.MoveNext()
                return True
            else:
                raise Error_Logeo(
                        "NewSeguridad"
                        , "__TraerGrupos"
                        , "No se encontraron grupos asignados, no podra utilizar el sistema")

     
    def __TraerPermisos(self):
        WebService = WebServices.soap.WebService(
                        self.getUrlServidorWeb()
                        , self.getHostServidorWeb()
                        , self.getProxy()
                        , self.getTipoServidor()
                        , self.getReintentos())
        Parametros = {
                        1:('IdUsr',str(self.getIdUsuario()))
                        ,2:('IdAplicacion',str(PRG_STOCK))
                        ,3:('TipoRespuesta','Python')}
            
        if WebService.Enviar(
                    'SEG_PermisosXId'
                    ,'www.osplad.org.ar'
                    , Parametros) == True:
            self.__handler.AvanzarBarra("Leyendo permisos del usuario, espere por favor...")   
            if WebService.Count()> 0:
                while WebService.BOF()!= True and WebService.EOF()!= True:
                    self._AddPermiso(
                            int(WebService.Fields("Id_GrupoStock"))
                            ,WebService.Fields("Tag")
                            ,WebService.Fields("Descripcion"))
                    WebService.MoveNext()
                return True
            else:
                raise Error_Logeo(
                            "NewSeguridad"
                            , "__TraerPermisos"
                            , "No se encontraron permisos asignados, no podra usar el sistema")
    def __CargarDatosFijos(self):
        self.__handler.AvanzarBarra("Cargando dependencias, espere por favor...")
        self.__DF_DependenciasDeGruposDeStock()
        self.__handler.AvanzarBarra("Cargando Depositos, espere por favor...")
        self.__DF_DepositosxIdUsuario()
        self.__handler.AvanzarBarra("Cargando estado de articulos, espere por favor...")
        self.__DF_EstadoArticuloEnviado()
        self.__handler.AvanzarBarra("Cargando estados de pedidos, espere por favor...")
        self.__DF_Estados_Pedidos()
        self.__handler.AvanzarBarra("Cargando grupos del usuario, espere por favor...")
        self.__DF_GruposArticulosXIdUser()
        self.__handler.AvanzarBarra("Cargando stock del usuario, espere por favor...")
        self.__DF_GruposDeStockXIdUsuario()
        self.__handler.AvanzarBarra("Cargando dependencias de stock, espere por favor...")
        self.__DF_GrupoStockHijos()
        self.__handler.AvanzarBarra("Cargando metodos de envio, espere por favor...")
        self.__DF_MetodosDeEnvio()
        self.__handler.AvanzarBarra("Cargando modo de envio, espere por favor...")
        self.__DF_ModosDeEnvio()
        self.__handler.AvanzarBarra("Cargando patrones de busquedas, espere por favor...")
        self.__DF_PatronesDeBusqueda()
        self.__handler.AvanzarBarra("Cargando prioridades, espere por favor...")
        self.__DF_Prioridades()
        self.__handler.AvanzarBarra("Cargando provincias, espere por favor...")
        self.__DF_Provincias()
        self.__handler.AvanzarBarra("Cargando tipos de articulos, espere por favor...")
        self.__DF_TipoDeArticulosXGruposDeArticulo()
        self.__handler.AvanzarBarra("Cargando tipo de egresos, espere por favor...")
        self.__DF_TipoDeEgresos()
        self.__handler.AvanzarBarra("Cargando medidas garantias, espere por favor...")
        self.__DF_TipoMedidasGarantias()
        self.__handler.AvanzarBarra("Cargando tipo de ingresos, espere por favor...")
        self.__DF_TiposDeIngresos()
        self.__handler.AvanzarBarra("Cargando tipo de movimientos, espere por favor...")
        self.__DF_TiposDeMovimientos()
        self.__handler.AvanzarBarra("Generando interfaz de usuario, espere por favor...")
        return True
    def __DF_GruposDeStockXIdUsuario(self):
        valor = {}
        cargoperfil = False
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        
        Parametros = {
                      1:('Id_User',str(self.getIdUsuario()))
                      ,2:('TipoRespuesta','Python')
                      }
        
        if WebService.Enviar( 
                'SELECT_DatosFijos_GruposDeStockXIdUsuario', 
                'www.osplad.org.ar',
                Parametros) == True:
            if WebService.Count() != 0:       
                while WebService.BOF() != True and WebService.EOF()!= True:
                    if cargoperfil == False:
                        self.SetPerfilActual(int(WebService.Fields('ID_GrupoStock')))
                        cargoperfil = True
                        valor[WebService.GetIndex()] = datosfijos.GruposStock(
                                                        WebService.Fields('ID_GrupoStock')
                                                        ,WebService.Fields('Nombre')
                                                        ,WebService.Fields('Descripcion')
                                                        ,WebService.Fields('Ubicacion')
                                                        ,WebService.Fields('Direccion')
                                                        ,WebService.Fields('Localidad')
                                                        ,WebService.Fields('Provincia')
                                                        ,WebService.Fields('CodigoPostal')
                                                        ,WebService.Fields('Telefonos')
                                                        ,WebService.Fields('Email')
                                                        ,WebService.Fields('GenerarNroSerie')
                                                        ,WebService.Fields('TipoStock'))
#                    valor[WebService.GetIndex()] = {
#                        'ID_GrupoStock':WebService.Fields('ID_GrupoStock')
#                        ,'Nombre':WebService.Fields('Nombre')
#                        ,'Descripcion':WebService.Fields('Descripcion')
#                        ,'Ubicacion':WebService.Fields('Ubicacion')
#                        ,'Direccion':WebService.Fields('Direccion')
#                        ,'Localidad':WebService.Fields('Localidad')
#                        ,'Provincia':WebService.Fields('Provincia')
#                        ,'CodigoPostal':WebService.Fields('CodigoPostal')
#                        ,'Telefonos':WebService.Fields('Telefonos')
#                        ,'Email' : WebService.Fields('Email')
#                        ,'GenerarNroSerie' : WebService.Fields('GenerarNroSerie')
#                        ,'TipoStock':WebService.Fields('TipoStock')}
                    WebService.MoveNext()
                self._AgregarDatoFijo('Perfiles',valor)
                return True
           
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_GruposDeStockXIdUsuario"
                                , "El usuario no pertenece a ningun stock")
    def __DF_DependenciasDeGruposDeStock(self):
        valor = {}
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        Parametros = {
                      1:('IdUser',str(self.getIdUsuario()))
                      ,2:('TipoRespuesta','Python')
                      }
        if WebService.Enviar( 
                             'SELECT_DatosFijos_DependenciasDeGruposDeStock', 
                            'www.osplad.org.ar',
                            Parametros) == True:
            if WebService.Count() > 0:  
                self._setTieneStockPadre(True)
                while WebService.BOF() != True and WebService.EOF()!= True:
                    valor[WebService.GetIndex()] = datosfijos.DependenciasxStock(
                                                   WebService.Fields('ID_GrupoStock')
                                                   , WebService.Fields('ID_GrupoStockPadre')
                                                   , WebService.Fields('NombrePadre'))
#                    valor[WebService.GetIndex()] = {
#                                'IDGrupoStock':WebService.Fields('ID_GrupoStock')
#                                ,'IDGrupoStockPadre':WebService.Fields('ID_GrupoStockPadre')
#                                ,'NombrePadre':WebService.Fields('NombrePadre')
#                                }
                    WebService.MoveNext()
                self._AgregarDatoFijo('PadreGrupoStock',valor)
                return True
            else:
                self._setTieneStockPadre(False)
                return True
    def __DF_GrupoStockHijos(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('IdUser',str(self.getIdUsuario()))
                      ,2:('TipoRespuesta','Python')
                      }
        if WebService.Enviar( 
                        'SELECT_DatosFijos_GrupoStockHijos', 
                        'www.osplad.org.ar',
                        Parametros) == True:
            if WebService.Count() != 0:
                self._setTieneStockHijos(True)
                while WebService.BOF() != True and WebService.EOF()!= True:
                    valor[WebService.GetIndex()] = datosfijos.StockHijos(
                                                   WebService.Fields('IdPadre')
                                                   , WebService.Fields('IdGrupoStockHijo')
                                                   , WebService.Fields('NombreStockHijo'))
#                    valor[WebService.GetIndex()] = {
#                                    'IDGrupoStockPadre':WebService.Fields('IdPadre'),
#                                    'IDGrupoStockHijo':WebService.Fields('IdGrupoStockHijo'),
#                                    'NombreStockHijo':WebService.Fields('NombreStockHijo')}
                    WebService.MoveNext()
                self._AgregarDatoFijo('GrupoStockHijos',valor)
                return True
            else:
                self._setTieneStockHijos(False)
                return True

    def __DF_TipoMedidasGarantias(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('TipoRespuesta','Python')
                     }
        if WebService.Enviar( 
                            'SELECT_DatosFijos_TipoMedidasGarantias', 
                            'www.osplad.org.ar',
                            Parametros) == True:
                                
            if WebService.Count() != 0 :
                while WebService.BOF() != True and WebService.EOF()!= True:
                    valor[WebService.GetIndex()] = datosfijos.Generico(
                                                   WebService.Fields("ID_TiemposDeGarantias")
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion'))
#                    valor[WebService.GetIndex()] = {
#                            'ID_TiemposDeGarantias':WebService.Fields('ID_TiemposDeGarantias'),
#                            'Codigo':WebService.Fields('Codigo'),
#                            'Descripcion':WebService.Fields('Descripcion')}
                    WebService.MoveNext()
                self._AgregarDatoFijo('TipoMedidasGarantias',valor)
                return True          
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_TipoMedidasGarantias"
                                , "No se encontraron tipos de medidas garantias cargadas")
    def __DF_GruposArticulosXIdUser(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('Id_User',str(self.getIdUsuario()))
                      ,2:('TipoRespuesta','Python')
                      }
        if WebService.Enviar( 
                    'SELECT_DatosFijos_GruposArticulosXIdUser', 
                    'www.osplad.org.ar',
                    Parametros) == True:
                                
            if WebService.Count() != 0 :
                while WebService.BOF() != True and WebService.EOF() != True: 
                    valor[WebService.GetIndex()] = datosfijos.ArticulosxUsuario(
                                                   WebService.Fields('ID_GrupoArticulo')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion')
                                                   , WebService.Fields('ID_GrupoStock'))  
#                    valor[WebService.GetIndex()] = {
#                                    'Codigo':WebService.Fields('Codigo'),
#                                    'Id_GrupoArticulo':WebService.Fields('ID_GrupoArticulo'),
#                                    'Descripcion':WebService.Fields('Descripcion')
#                                    ,'IdGrupoStock':WebService.Fields('ID_GrupoStock')}
                                    
                    WebService.MoveNext()
                self._AgregarDatoFijo('GruposArticulos',valor)
                return True          
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_GruposArticulosXIdUser"
                                , "El usuario no tiene autorizacion para ver ningun grupo de usuario")
    def __DF_PatronesDeBusqueda(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('TipoRespuesta','Python')
                      }
        if WebService.Enviar('SELECT_DatosFijos_PatronesDeBusqueda', 
                            'www.osplad.org.ar',
                            Parametros) == True:  
            if WebService.Count()!= 0 :
                    while WebService.BOF() != True and WebService.EOF() != True:
                        valor[WebService.GetIndex()] = datosfijos.Generico(
                                                       WebService.Fields('Id_patronDeBusqueda')
                                                       , WebService.Fields('Codigo')
                                                       , WebService.Fields('Descripcion'))
#                        valor[WebService.GetIndex()] = {
#                                        'Id_PatronBusqueda':WebService.Fields('Id_patronDeBusqueda'),
#                                        'Codigo':WebService.Fields('Codigo'),
#                                        'Descripcion':WebService.Fields('Descripcion')
#                                                        }
                        WebService.MoveNext()
                    self._AgregarDatoFijo('PatronDeBusqueda',valor)
                    return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_PatronesDeBusqueda"
                                , "El usuario no tiene autorizacion para ver ningun grupo de usuario")
    
    def __DF_TipoDeArticulosXGruposDeArticulo(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                    1:('id_User',str(self.getIdUsuario()))
                    ,2:('TipoRespuesta','Python')}
        if WebService.Enviar(
                'SELECT_DatosFijos_TipoDeArticulosXGruposDeArticulo', 
                'www.osplad.org.ar',
                Parametros) == True:
                            
            if WebService.Count()!= 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.TipoDeArticulosxGrupo(
                                                   WebService.Fields('ID_TipoArticulo')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion')
                                                   , WebService.Fields('ID_GrupoArticulo')
                                                   , WebService.Fields('ID_GrupoStock'))
#                    valor[WebService.GetIndex()] = {
#                            'ID_TipoArticulo':WebService.Fields('ID_TipoArticulo'),
#                            'Codigo':WebService.Fields('Codigo'),
#                            'Descripcion':WebService.Fields('Descripcion'),
#                            'Id_GrupoArticulo':WebService.Fields('ID_GrupoArticulo'),
#                            'IdGrupoStock':WebService.Fields('ID_GrupoStock')
#                                                    }
                    WebService.MoveNext()
                self._AgregarDatoFijo('TiposDeArticulo',valor)
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_TipoDeArticulosXGruposDeArticulo"
                                , "No se pudo establecer los tipo de articulos x grupos de articulos asignados")
             
    def __DF_DepositosxIdUsuario(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:("IdUser",str(self.getIdUsuario()))
                      ,2:('TipoRespuesta','Python')
                      }
        if WebService.Enviar(
                'SELECT_DatosFijos_DepositosxIdUsuario',
                'www.osplad.org.ar',
                Parametros) == True:
            if WebService.Count() > 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.Depositos(
                                                   WebService.Fields('Id_Deposito')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion')
                                                   , WebService.Fields('Ubicacion')
                                                   , WebService.Fields('ID_GrupoStock'))
#                    valor[WebService.GetIndex()] = {
#                                    'Id_Deposito':WebService.Fields('Id_Deposito'),
#                                    'Codigo':WebService.Fields('Codigo'),
#                                    'Descripcion':WebService.Fields('Descripcion'),
#                                    'Ubicacion':WebService.Fields('Ubicacion'),
#                                    'Id_GrupoStock':WebService.Fields('ID_GrupoStock')
#                                                    }
                    WebService.MoveNext()
                self._AgregarDatoFijo('DepositosxPerfil',valor)
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_DepositosxIdUsuario"
                                , "No se pudo establecer los depositos asignados")
    def __DF_TiposDeMovimientos(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {1:('TipoRespuesta','Python')}
        if WebService.Enviar('SELECT_DatosFijos_TiposDeMovimientos',
                            'www.osplad.org.ar',
                            Parametros) == True: 
            if WebService.Count() > 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.Generico(
                                                   WebService.Fields('ID')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion'))
#                    valor[WebService.GetIndex()] = {
#                                'ID':WebService.Fields('ID'),
#                                'Codigo':WebService.Fields('Codigo'),
#                                'Descripcion':WebService.Fields('Descripcion')}
                    WebService.MoveNext()
                self._AgregarDatoFijo('TiposDeMovimientos',valor)
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_TiposDeMovimientos"
                                , "No se encontraron tipo de movimientos")
                
    def __DF_TiposDeIngresos(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('TipoRespuesta','Python')
                      }
        if WebService.Enviar('SELECT_DatosFijos_TiposDeIngresos',
                            'www.osplad.org.ar',
                            Parametros) == True: 
            if WebService.Count() > 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.Generico(
                                                   WebService.Fields('ID')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion'))
#                    valor[WebService.GetIndex()] = {
#                            'Id_TipoIngreso':WebService.Fields('ID'),
#                            'Codigo':WebService.Fields('Codigo'),
#                            'Descripcion':WebService.Fields('Descripcion')}
                    WebService.MoveNext()
                self._AgregarDatoFijo('TiposDeIngresosDeArticulos',valor)
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_TiposDeIngresos"
                                , "No se encontraron tipos de ingresos")
                
    def __DF_TipoDeEgresos(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('TipoRespuesta','Python')
                      }
        if WebService.Enviar('SELECT_DatosFijos_TipoDeEgresos',
                            'www.osplad.org.ar',
                            Parametros) == True: 
            if WebService.Count() > 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.Generico(
                                                   WebService.Fields('ID')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion'))
#                    valor[WebService.GetIndex()] = {
#                                'ID':WebService.Fields('ID'),
#                                'Codigo':WebService.Fields('Codigo'),
#                                'Descripcion':WebService.Fields('Descripcion')}
                    WebService.MoveNext()
                self._AgregarDatoFijo('TiposDeEgresosDeArticulos',valor)
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_TipoDeEgresos"
                                , "No se encontraron tipos de egresos")
    def __DF_Provincias(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('TipoRespuesta','Python')
                      }
        if WebService.Enviar('SELECT_DatosFijos_Provincias',
                            'www.osplad.org.ar',
                            Parametros) == True: 
            if WebService.Count() != 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.Generico(
                                                  WebService.Fields('CodProvincial')
                                                  , WebService.Fields('Nombre')
                                                  , WebService.Fields('Nombre')) 
#                    valor[WebService.GetIndex()] = {
#                                'ID':WebService.Fields('CodProvincial'),
#                                'Nombre':WebService.Fields('Nombre')}
                    WebService.MoveNext()
                self._AgregarDatoFijo('Provincias',valor)
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_Provincias"
                                , "No se encontraron provincias cargadas")

    def __DF_Prioridades(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('TipoRespuesta','Python')
                      }
        if WebService.Enviar('SELECT_DatosFijos_Prioridades',
                            'www.osplad.org.ar',
                            Parametros) == True: 
            if WebService.Count() != 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.Generico(
                                                   WebService.Fields('ID')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion'))
#                    valor[WebService.GetIndex()] = {
#                            'ID':WebService.Fields('ID'),
#                            'Codigo':WebService.Fields('Codigo')
#                            ,'Descripcion':WebService.Fields("Descripcion")}
                    WebService.MoveNext()
                self._AgregarDatoFijo('Prioridades',valor)
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_Prioridades"
                                , "No se encontraron prioridades de pedidos  cargadas")
    def __DF_Estados_Pedidos(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('TipoRespuesta','Python')
                      }
        if WebService.Enviar('SELECT_DatosFijos_Estados_Pedidos',
                            'www.osplad.org.ar',
                            Parametros) == True: 
            if WebService.Count() != 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.Generico(
                                                   WebService.Fields('ID')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion'))
#                    valor[WebService.GetIndex()] = {
#                        'ID':WebService.Fields('ID'),
#                        'Codigo':WebService.Fields('Codigo')
#                        ,'Descripcion':WebService.Fields("Descripcion")}
                    WebService.MoveNext()
                self._AgregarDatoFijo('Estado_Pedidos',valor)
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_Estados_Pedidos"
                                , "No se encontraron estados de pedidos  cargados")
    def __DF_MetodosDeEnvio(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('TipoRespuesta','Python')
                      }
        if WebService.Enviar('SELECT_DatosFijos_MetodosDeEnvio',
                            'www.osplad.org.ar',
                            Parametros) == True: 
            if WebService.Count() != 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.Generico(
                                                   WebService.Fields('ID')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion'))
#                    valor[WebService.GetIndex()] = {
#                            'ID':WebService.Fields('ID'),
#                            'Codigo':WebService.Fields('Codigo')
#                            ,'Descripcion':WebService.Fields("Descripcion")}
                    WebService.MoveNext()
                self._AgregarDatoFijo('MetodosDeEnvio',valor)
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_MetodosDeEnvio"
                                , "No se encontraron metodos de envio cargados")
    def __DF_ModosDeEnvio(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('TipoRespuesta','Python')
                      }
        if WebService.Enviar('SELECT_DatosFijos_ModosDeEnvio',
                            'www.osplad.org.ar',
                            Parametros) == True: 
            if WebService.Count() != 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.Generico(
                                                   WebService.Fields('ID')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion'))
#                    valor[WebService.GetIndex()] = {
#                            'ID':WebService.Fields('ID'),
#                            'Codigo':WebService.Fields('Codigo')
#                            ,'Descripcion':WebService.Fields("Descripcion")}
                    WebService.MoveNext()
                self._AgregarDatoFijo('ModosDeEnvio',valor)
                return True
            else:
                raise Error_Logeo(
                                "NewSeguridad"
                                , "__DF_ModosDeEnvio"
                                , "No se encontraron modos de envio cargados")
    def __DF_EstadoArticuloEnviado(self):
        WebService = WebServices.soap.WebService(
                     self.getUrlServidorWeb()
                     , self.getHostServidorWeb()
                     , self.getProxy()
                     , self.getTipoServidor()
                     , self.getReintentos())
        valor = {}
        Parametros = {
                      1:('TipoRespuesta','Python')
                      }
        if WebService.Enviar('SELECT_DatosFijos_EstadoArticuloEnviado',
                            'www.osplad.org.ar',
                            Parametros) == True: 
            if WebService.Count() != 0 :
                while WebService.BOF() != True and WebService.EOF() != True:
                    valor[WebService.GetIndex()] = datosfijos.Generico(
                                                   WebService.Fields('Id')
                                                   , WebService.Fields('Codigo')
                                                   , WebService.Fields('Descripcion'))
#                    valor[WebService.GetIndex()] = {
#                            'ID':WebService.Fields('Id'),
#                            'Codigo':WebService.Fields('Codigo')
#                            ,'Descripcion':WebService.Fields("Descripcion")}
                    WebService.MoveNext()
                self._AgregarDatoFijo('EstadosArticulosEnviados',valor)
                return True
            else:
                raise Error_Logeo.Error_Logeo(
                                "NewSeguridad"
                                , "__DF_EstadoArticuloEnviado"
                                , "No se encontraron estados de articulos enviados")



 
                

  
            
class Error_Logeo(Exception):
    """Excepcion: Se produce cuando falla logeo de usuario
    Parametros:
    -clase: Nombre de la clase que llama al metodo
    -metodo: Nombre del metodo que causa la excepcion
    -mensaje: mensaje de error"""
    def __init__(self,clase,metodo,mensaje):
        self.__Clase = clase
        self.__Metodo = metodo
        self.__Mensaje = mensaje
        self.__ErrorDescripcion = self.__Mensaje
    def __str__(self):
        return repr(self.__ErrorDescripcion)
        
            

        
        
    
        
    
                                        
            
    